home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / qed_397 / sourcen / menu.c < prev    next >
C/C++ Source or Header  |  1997-01-14  |  13KB  |  616 lines
  1. #include <errno.h>
  2.  
  3. #include "global.h"
  4. #include "av.h"
  5. #include "block.h"
  6. #include "clipbrd.h"
  7. #include "desktop.h"
  8. #include "disk.h"
  9. #include "edit.h"
  10. #include "error.h"
  11. #include "file.h"
  12. #include "find.h"
  13. #include "fontsel.h"
  14. #include "icon.h"
  15. #include "kurzel.h"
  16. #include "makro.h"
  17. #include "obj.h"
  18. #include "options.h"
  19. #include "projekt.h"
  20. #include "rsc.h"
  21. #include "se.h"
  22. #include "scroll.h"
  23. #include "set.h"
  24. #include "text.h"
  25. #include "umbruch.h"
  26. #include "windows.h"
  27. #include "menu.h"
  28.  
  29.  
  30. /****** VARIABLES ************************************************************/
  31.  
  32. /* Menuenummer zu einer Aktion */
  33. WORD menu_nr[] =    {MUNDO, MCUT, MCOPY, MPASTE, MCLEAR, MSELALL,
  34.           MCLOSE, -1, MOPEN, MINFO, -1, MLEFT, MRIGHT,
  35.           MFORMAT, MPRINT, MABAND, MSAVE, MSAVENEW, MFIND,
  36.           MFNDGOON, MADD, -1, MGOTO, MSCUT, -1, -1,
  37.           MSTAB2LZ, -1, MSLZ2TAB, -1, MZEICHEN, MSWAP,
  38.           MLEFT, MRIGHT, MSMALL, MBIG, MSMALLBIG, MCAPS,
  39.           -1, -1, MUMLAUTE, -1, MFEHLERSPRUNG};
  40.  
  41.  
  42.  
  43. /*****************************************************************************/
  44.  
  45. LOCAL WORD    menu_width;
  46. LOCAL VOID    mclearup     (VOID);
  47.  
  48. /*****************************************************************************/
  49.  
  50. VOID    set_overwrite(BOOLEAN over)
  51. {
  52.     if (overwrite && !over)     /* einfügen */
  53.     {
  54.         overwrite = FALSE;
  55.         menu_icheck(menu, MOOVERW, FALSE);
  56.         menu_icheck(menu, MOEINF, TRUE);
  57.     }
  58.     else                /* überschreiben */
  59.     {
  60.         overwrite = TRUE;
  61.         menu_icheck(menu, MOOVERW, TRUE);
  62.         menu_icheck(menu, MOEINF, FALSE);
  63.     }
  64. }
  65.  
  66. /***************************************************************************/
  67.  
  68. BOOLEAN menu_key(MKINFO *mk)
  69. {
  70.     WORD        title, item, kreturn, kstate;
  71.  
  72.     updt_menu();
  73.     if (mk->shift)                                    /* eventuelle SHIFT-Tasten ausblenden */
  74.     {
  75.         global_shift = TRUE;
  76.         mk->shift = FALSE;
  77.         kstate = mk->kstate;
  78.         mk->kstate &= ~3;
  79.         kreturn = mk->kreturn;
  80.         mk->kreturn &= ~NKF_SHIFT;
  81.     }
  82.     if (my_menu_key (menu, mk, &title, &item))
  83.     {
  84.         hndl_menu(title, item, FALSE);        /* Menü aufrufen */
  85.         return (TRUE);                                /* fertig */
  86.     }
  87.     if (global_shift)                                /* und wieder einblenden */
  88.     {
  89.         mk->shift = TRUE;
  90.         mk->kstate = kstate;
  91.         mk->kreturn = kreturn;
  92.     }
  93.     return (FALSE);
  94. } /* menu_key */
  95.  
  96.  
  97. LOCAL VOID multitest_action(SET icons, SET action)
  98. {
  99.     WORD    icp[MAX_ICON_ANZ], ic;
  100.     SET    help;
  101.     WORD    i;
  102.  
  103.     i = all_icons(icp);
  104.     setclr(action);
  105.     while ((--i)>=0)
  106.     {
  107.         ic = icp[i];
  108.         if(setin(icons,ic))
  109.         {
  110.             Icon_exist(ic,help);
  111.             setor(action,help);
  112.         }
  113.     }
  114. }
  115.  
  116. GLOBAL VOID set_menu(WORD item, BOOLEAN yes)
  117. {
  118.     if (((menu[item].ob_state & DISABLED) == 0) != yes)
  119.         menu_ienable (menu, item, yes);
  120. }
  121.  
  122. GLOBAL VOID mark_menu(WORD item, BOOLEAN yes)
  123. {
  124.     if (((menu[item].ob_state & CHECKED) != 0) != yes)
  125.         menu_icheck (menu, item, yes);
  126. }
  127.  
  128. GLOBAL VOID fillup_menu (WORD item, CONST UBYTE *new_text, WORD free)
  129. {
  130.     WORD    len, max_len;
  131.     UBYTE *str;
  132.  
  133.     str = menu[item].ob_spec.free_string + free;
  134.     len = (short) strlen(new_text);
  135.     max_len = (short) strlen(str) - 4;        /* ' ?? ' Shortcut nicht überscrieben! */
  136.     if (len > max_len)
  137.         len = max_len;
  138.     str = COPYB(str, new_text, len);
  139.     len = max_len - len;                     /* Restlänge */
  140.     while ((--len) >= 0)
  141.         *str++ = ' ';
  142. }
  143.  
  144.  
  145. LOCAL VOID set_MCOPY(char *n)
  146. {
  147.     fillup_menu(MCOPY, n, 2);
  148.     set_menu(MCOPY, TRUE);
  149. }
  150.  
  151.  
  152. VOID updt_menu (VOID)
  153. {
  154.     WINDP        window;
  155.     SET        all_actions;
  156.     BOOLEAN    yes;
  157.     WORD        i, nr;
  158.  
  159.     setclr(all_actions);
  160.     window = top();
  161.  
  162.     if (sel_window != NULL) /* Aktion für selektierte Objekte */
  163.     {
  164.         if (sel_window->class == DESK)
  165.             multitest_action(sel_objs,all_actions);
  166.         else
  167.         {
  168.             Icon_exist(sel_window->link+SUB_ICON,all_actions);
  169.         }
  170.         mark_menu(MSEL,FALSE);
  171.         set_menu(MSEL,FALSE);
  172.         set_menu(MSETMARK,FALSE);
  173.     }
  174.     else            /* Aktionen für oberstes Fenster */
  175.     {
  176.         if (window!=NULL)
  177.             Icon_exist(window->link, all_actions);
  178.         else
  179.             Icon_exist(0,all_actions);
  180.  
  181.         if (window!=NULL && window->class == CLASS_EDIT && !(window->flags & WI_ICONIFIED))
  182.         {
  183.             TEXTP t_ptr = get_text(window->link);
  184.  
  185.             mark_menu(MSEL, (!ctrl_mark_mode && t_ptr->blk_mark_mode));
  186.             set_menu(MSEL, !ctrl_mark_mode);
  187.             set_menu(MSETMARK,TRUE);
  188.         }
  189.         else
  190.         {
  191.             mark_menu(MSEL,FALSE);
  192.             set_menu(MSEL,FALSE);
  193.             set_menu(MSETMARK,FALSE);
  194.         }
  195.     }
  196.  
  197.     /* Desk + 2 Fenster || wind-global */
  198.     yes = ((num_windows(NIL,SRCH_OPENED)>=3) || wind_cycle);
  199.     set_menu(MCYCLE, yes);
  200.     mark_menu(MSRECORD, makro_rec);
  201.  
  202.     for (i=DO_ANZ; (--i)>=0; )
  203.     {
  204.         nr = menu_nr[i];
  205.         if (nr > -1)
  206.             set_menu(nr,setin(all_actions,i));
  207.     }
  208.     if (setin(all_actions, DO_LINECOPY))
  209.         set_MCOPY(STRING(LCOPYSTR));
  210.     else if (setin(all_actions, DO_COPY))
  211.         set_MCOPY(STRING(COPYSTR));
  212.  
  213.     setup_semenu();                /* -> comm.c */
  214. } /* updt_menu */
  215.  
  216.  
  217. /*
  218.  * Alle Menütitel abschalten, nur die ACC bleiben aktiv.
  219.  * Wird bei All-Iconify benutzt.
  220.  */
  221. #define THEBAR        1                            /* Objekt-Nummer der Menüzeile */
  222. #define THEACTIVE 2                            /* Objekt-Nummer der aktiven Menüs */
  223. #define THEFIRST    3                            /* Objekt-Nummer des ersten Menüs */
  224.  
  225. VOID    enable_menu(BOOLEAN enable)
  226. {
  227.     WORD    titel;
  228.  
  229.     wind_update(BEG_UPDATE);
  230.     titel = menu[THEFIRST].ob_next;
  231.     while (titel != THEACTIVE)
  232.     {
  233.         disable_objc(menu, titel, !enable);
  234.         titel = menu[titel].ob_next;
  235.     }
  236.     if (enable)
  237.         menu[THEACTIVE].ob_width = menu_width;
  238.     else
  239.     {
  240.         if (menu[THEACTIVE].ob_width != menu[THEFIRST].ob_width)
  241.         {
  242.             menu_width = menu[THEACTIVE].ob_width;
  243.             menu[THEACTIVE].ob_width = menu[THEFIRST].ob_width;
  244.         }
  245.     }
  246.     /* About-Eintrag auch noch */
  247.     menu_ienable(menu, MABOUT, enable);
  248.     if (!aes41 || (menu_bar(NULL, -1) == gl_apid))
  249.         menu_bar(menu, TRUE);
  250.  
  251.     wind_update(END_UPDATE);
  252. } /* enable_menu */
  253.  
  254. /*****************************************************************************/
  255.  
  256. LOCAL VOID do_multi_action(WORD action)
  257. {
  258.     WORD    icp[MAX_ICON_ANZ], ic;
  259.     SET    sel_icons;
  260.     WORD    i, anz;
  261.  
  262.     anz = all_icons(icp);
  263.     setcpy(sel_icons, sel_objs);
  264.     for (i=0; i<anz; i++)                /* In dieser Reihenfolge! */
  265.     {
  266.         ic = icp[i];
  267.         if (setin (sel_icons, ic))
  268.         {
  269.             if (do_icon(ic,action)<0 && action==DO_OPEN)
  270.             {
  271.                 note(1, NOWINDOW);
  272.                 break;
  273.             }
  274.         }
  275.     }
  276. }
  277.  
  278. VOID do_action(WORD action)
  279. {
  280.     if (sel_window!=NULL)
  281.     {
  282.         if (sel_window->class == DESK)
  283.             do_multi_action(action);
  284.         else
  285.         {
  286.             if (do_icon(sel_window->link+SUB_ICON,action)<0 && action==DO_OPEN)
  287.                 note(1, NOWINDOW);
  288.         }
  289.     }
  290.     else
  291.     {
  292.         WINDOWP w = top();
  293.  
  294.         if (w!=NULL)
  295.             do_icon(w->link,action);
  296.         else
  297.             do_icon(0,action);
  298.     }
  299. }
  300.  
  301.  
  302. LOCAL VOID    menu_help(WORD title, WORD item)
  303. {
  304.     UBYTE help[128], *p1, str[128];
  305.  
  306.     /* Spezial-Fälle: besonderer Text */
  307.     if (item >= MMARKE1 && item <= MMARKE5)
  308.         strcpy(str, STRING(HYPMARKESTR));
  309.     else if (item == MPROJEKT)
  310.         strcpy(str, STRING(DEFPRJSTR));
  311.     else if (title == MSHELL)
  312.         strcpy(str, "Shell");
  313.     else
  314.     {
  315.         /* Spezial-Fälle: Item ummappen */
  316.         if (item == MOEINF)
  317.             item = MOOVERW;
  318.  
  319.         /* die führenden '  ' überspringen und das letzte auch nicht */
  320.         strcpy(help, menu[item].ob_spec.free_string);
  321.         strncpy(str, help + 2, (short) strlen(help) - 3);
  322.         p1 = strrchr(str, ' ');
  323.         while (*(p1--) == ' ')    /* Leerzeichen weg */
  324.             ;
  325.         *(p1+2) = EOS;
  326.         if (str[strlen(str) - 1] == '.')        /* es folgen '...' */
  327.             str[strlen(str) - 3] = EOS;
  328.     }
  329.     if (str[0] != EOS)
  330.         call_hyp(str);
  331. }
  332.  
  333.  
  334. VOID hndl_menu (WORD title, WORD item, BOOLEAN ctrl)
  335. {
  336.     WINDP w;
  337.     WORD    action, antw, anz;
  338.     UBYTE str[10];
  339.  
  340.     if (ctrl)
  341.         menu_help(title, item);
  342.     else
  343.     {
  344.         menu_tnormal(menu, title, FALSE);             /* Titel invers darstellen */
  345.         action = -1;
  346.         switch (item)
  347.         {
  348.             case MABOUT :
  349.                 info_desktop();
  350.                 break;
  351.             /* ==== Datei ==== */
  352.             case MNEWTEXT    :
  353.                 new_edit();
  354.                 break;
  355.             case MOPEN     :
  356.                 if (sel_window==NULL)
  357.                 {
  358.                     if (do_icon(idisk,DO_OPEN)<0)
  359.                         note(1, NOWINDOW);
  360.                 }
  361.                 else
  362.                     action = DO_OPEN;
  363.                 break;
  364.             case MADD    :
  365.                 action = DO_ADD;
  366.                 break;
  367.             case MNEWPROJ :
  368.                 new_prj();
  369.                 break;
  370.             case MCLOSE :
  371.                 if (no_desktop)
  372.                     action = DO_DESTRUCT;
  373.                 else
  374.                     action = DO_CLOSE;
  375.                 break;
  376.             case MCLEAR :
  377.                 action = DO_CLEAR;
  378.                 break;
  379.             case MCYCLE :
  380.                 if ((wind_cycle) && (send_avkey(4, 0x1117)))    /* ^W */
  381.                     break;
  382.                 cycle_window();
  383.                 break;
  384.             case MSAVE:
  385.                 action = DO_SAVE;
  386.                 break;
  387.             case MSAVENEW:
  388.                 action = DO_SAVENEW;
  389.                 break;
  390.             case MABAND :
  391.                 action = DO_ABAND;
  392.                 break;
  393.             case MPRINT :
  394.                 action = DO_PRINT;
  395.                 break;
  396.             case MINFO     :
  397.                 action = DO_INFO;
  398.                 break;
  399.             case MQUIT2 :
  400.                 quick_close = TRUE;
  401.             case MQUIT :
  402.                 if (Icon_test(0,DO_DESTRUCT))
  403.                 {
  404.                     /* Fenster ist danach weg */
  405.                     menu_tnormal(menu, title, TRUE);
  406.                     Icon_edit(0,DO_DESTRUCT);
  407.                 }
  408.                 break;
  409.             /* ==== Bearbeiten ==== */
  410.             case MUNDO     :
  411.                 action = DO_UNDO;
  412.                 break;
  413.             case MCUT     :
  414.                 action = DO_CUT;
  415.                 break;
  416.             case MCOPY     :
  417.                 w = top();
  418.                 if (w!=NULL && w->class==CLASS_EDIT)
  419.                 {
  420.                     TEXTP t_ptr = get_text(w->link);
  421.                     if (t_ptr->block)
  422.                         action = DO_COPY;
  423.                     else
  424.                         action = DO_LINECOPY;
  425.                 }
  426.                 break;
  427.             case MPASTE :
  428.                 action = DO_PASTE;
  429.                 break;
  430.             case MSEL     :
  431.                 w = top();
  432.                 if (w!=NULL && w->class==CLASS_EDIT)
  433.                 {
  434.                     TEXTP t_ptr = get_text(w->link);
  435.                     if (t_ptr->blk_mark_mode)
  436.                         t_ptr->blk_mark_mode = FALSE;
  437.                     else
  438.                     {
  439.                         blk_demark(t_ptr);
  440.                         restore_edit();
  441.                         blk_mark(t_ptr,0);
  442.                         t_ptr->blk_mark_mode = TRUE;
  443.                     }
  444.                 }
  445.                 break;
  446.             case MSELALL :
  447.                 action = DO_SELALL;
  448.                 break;
  449.             case MFORMAT :
  450.                 action = DO_FORMAT;
  451.                 break;
  452.             case MSWAP:
  453.                 action = DO_SWAPCHAR;
  454.                 break;
  455.             case MLEFT     :
  456.                 if (global_shift)
  457.                     action = DO_ONE_LEFT;
  458.                 else
  459.                     action = DO_LEFT;
  460.                 break;
  461.             case MRIGHT :
  462.                 if (global_shift)
  463.                     action = DO_ONE_RIGHT;
  464.                 else
  465.                     action = DO_RIGHT;
  466.                 break;
  467.             case MSMALLBIG :
  468.                 action = DO_CHNG_SMBG;
  469.                 break;
  470.             case MBIG:
  471.                 action = DO_SMALL2BIG;
  472.                 break;
  473.             case MSMALL :
  474.                 action = DO_BIG2SMALL;
  475.                 break;
  476.             case MCAPS:
  477.                 action = DO_CAPS;
  478.                 break;
  479.             /* ==== Suchen ==== */
  480.             case MFIND     :
  481.                 if (global_shift)
  482.                     do_icon(idisk, DO_FIND);
  483.                 else
  484.                     action = DO_FIND;
  485.                 break;
  486.             case MFNDGOON:
  487.                 action = DO_FINDNEXT;
  488.                 break;
  489.             case MGOTO     :
  490.                 action = DO_GOTO;
  491.                 break;
  492.             case MSETMARK:
  493.                 w = top();
  494.                 if (w!=NULL)
  495.                     config_marken(get_text(w->link));
  496.                 break;
  497.             case MMARKE1 :
  498.             case MMARKE2 :
  499.             case MMARKE3 :
  500.             case MMARKE4 :
  501.             case MMARKE5 :
  502.                 goto_marke(item-MMARKE1);
  503.                 break;
  504.             /* ==== Spezial ==== */
  505.             case MSRECORD:
  506.                 if (makro_rec)
  507.                     end_rec(TRUE);
  508.                 else
  509.                     start_rec();
  510.                 break;
  511.             case MSPLAY :
  512.                 anz = 1;
  513.                 if (global_shift)
  514.                 {
  515.                     objc_setstring(makrorep, MREPANZ, "");
  516.                     Arrow_mouse();
  517.                     antw = HndlDial (makrorep, MREPANZ, FALSE, NULL, NULL);
  518.                     Last_mouse();
  519.                     if (antw == MREPOK)
  520.                     {
  521.                         objc_getstring(makrorep,MREPANZ,str);
  522.                         anz = atoi(str);
  523.                     }
  524.                     else
  525.                         break;
  526.                 }
  527.                 start_play(-1, anz);
  528.                 break;
  529.             case MSMAKRO :
  530.                 makro_dial();
  531.                 break;
  532.             case MZEICHEN:
  533.                 action = DO_ZEICHTAB;
  534.                 break;
  535.             case MUMLAUTE:
  536.                 action = DO_UMLAUT;
  537.                 break;
  538.             case MFEHLER:
  539.                 fehler_box();
  540.                 break;
  541.             case MFEHLERSPRUNG:
  542.                 action = DO_FEHLER;
  543.                 break;
  544.             case MSCUT :
  545.                 action = DO_CUTLINES;
  546.                 break;
  547.             case MSTAB2LZ:
  548.                 action = DO_TAB2LZ;
  549.                 break;
  550.             case MSLZ2TAB:
  551.                 action = DO_LZ2TAB;
  552.                 break;
  553.             /* ==== Optionen ==== */
  554.             case MOEINF:
  555.                 set_overwrite(FALSE);
  556.                 break;
  557.             case MOOVERW:
  558.                 set_overwrite(TRUE);
  559.                 break;
  560.             case MSCLEAR :
  561.                 clearup_dial();
  562.                 break;
  563.             case MOFONT :
  564.                 if (select_font(vdi_handle))
  565.                     font_change();
  566.                 break;
  567.             case MGLOBALO:
  568.                 global_options();
  569.                 break;
  570.             case MLOCALOP:
  571.                 local_options();
  572.                 break;
  573.             case MAUTOSAVE :
  574.                 autosave_dial();
  575.                 break;
  576.             case MPROJEKT :
  577.                 open_def_prj();
  578.                 break;
  579.             case MTAKEPRJ :
  580.                 add_to_def();
  581.                 break;
  582.             case MSOPTION:
  583.                 antw = option_save(TRUE);
  584.                 if (antw != 0)
  585.                 {
  586.                     if (antw == -ENOSPC)
  587.                     {
  588.                         UBYTE    tmp[20];
  589.  
  590.                         make_shortpath(qed_path, tmp, 19);
  591.                         snote(1, NOSPACE, tmp);
  592.                     }
  593.                     else
  594.                         note(1, WRITEERR);
  595.                 }
  596.                  break;
  597.             /* ==== Shell ==== */
  598.             case MSOPT :
  599.             case MSQUIT :
  600.             case MSMAKEFILE :
  601.             case MSCOMP :
  602.             case MSMAKE :
  603.             case MSMAKEALL :
  604.             case MSLINK :
  605.             case MSEXEC :
  606.             case MSMAKEEXEC :
  607.                 hndl_es(item);
  608.             default:
  609.                 break;
  610.         }
  611.         if (action!=-1)
  612.             do_action(action);
  613.     } /* if ctrl */
  614.     menu_tnormal(menu, title, TRUE);                /* Titel wieder normal */
  615. } /* hndl_menu */
  616.